import ExifReader from 'exifreader';
import { ElMessage } from 'element-plus'
import * as piexif from 'piexifjs';

// utils/fileUtil.js
export function parseFileName(fullPath) {
  const fileName = fullPath.split(/[\\/]/).pop()
  const lastDotIndex = fileName.lastIndexOf('.')

  return {
    fullName: fileName,
    name: lastDotIndex === -1 ? fileName : fileName.substring(0, lastDotIndex),
    ext: lastDotIndex === -1 ? '' : fileName.substring(lastDotIndex + 1).toLowerCase()
  }
}

export async function getEXIFFromBlob(blob) {
  const arrayBuffer = await blob.arrayBuffer();
  const tags = ExifReader.load(arrayBuffer);
  return tags;

  // // 检查 EXIF 中的 XResolution/YResolution（常见于 JPEG/TIFF）
  // const xResolution = tags?.['XResolution']?.value;
  // const yResolution = tags?.['YResolution']?.value;

  // // 或检查 PNG 的 pHYs 块（如果存在）
  // const physChunk = tags?.['pHYs']?.value;
  // if (physChunk) {
  //   return {
  //     dpiX: physChunk.pixelsPerUnitX / 39.37, // 转换为 DPI（1 米 ≈ 39.37 英寸）
  //     dpiY: physChunk.pixelsPerUnitY / 39.37,
  //   };
  // }

  // return {
  //   dpiX: xResolution || 72, // 默认 72 DPI
  //   dpiY: yResolution || 72,
  // };
}

export function handleDPIByTags(tags) {
  const xResolution = tags?.['XResolution']?.value;
  const yResolution = tags?.['YResolution']?.value;

  // 或检查 PNG 的 pHYs 块（如果存在）
  const physChunk = tags?.['pHYs']?.value;
  if (physChunk) {
    return {
      dpiX: physChunk.pixelsPerUnitX / 39.37, // 转换为 DPI（1 米 ≈ 39.37 英寸）
      dpiY: physChunk.pixelsPerUnitY / 39.37,
    };
  }

  return {
    dpiX: parseInt(xResolution) || null, // 默认 72 DPI
    dpiY: parseInt(yResolution) || null,
  };
}

export function flattenTree(treeData) {
  const result = [];
  treeData.forEach(node => {
    result.push(node);
    if (node.children && node.children.length > 0) {
      result.push(...flattenTree(node.children));
    }
  });

  return result;
}

export function replacePictureDescription(text = '', picIs = '') {
  // 使用正则表达式匹配 "(图为xxx)" 格式
  const pattern = /（图为([^）]*)）/g;

  // 替换匹配到的内容
  return text.replace(pattern, `（图为${picIs}）`);
}

export function copyToClipboard(text) {
  if (!text) {
    ElMessage.warning('没有内容可复制')
    return
  }

  // 优先使用现代 Clipboard API
  if (navigator.clipboard && window.isSecureContext) {
    navigator.clipboard.writeText(text)
      .then(() => {
        ElMessage.success('复制成功')
      })
      .catch(() => {
        ElMessage.error('复制失败，请手动复制')
      })
  } else {
    // 降级处理：使用 document.execCommand('copy')
    const textArea = document.createElement('textarea')
    textArea.value = text
    document.body.appendChild(textArea)
    textArea.focus()
    textArea.select()
    
    try {
      const successful = document.execCommand('copy')
      if (successful) {
        ElMessage.success('复制成功')
      } else {
        ElMessage.error('复制失败，请手动复制')
      }
    } catch (err) {
      ElMessage.error('复制失败，请手动复制')
    } finally {
      document.body.removeChild(textArea)
    }
  }
}

export function handlePersonPositionData(person) {
  const { name, position } = person;
  if (!name || !position) return;
  const postData = {
    personName: name,
    positionTitles: position ? position.split(/[ 、]+/) : []
  }
  return postData;
}

export const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']
export function isImgByPath(path) {
  const extension = '.' + path?.split('.').pop().toLowerCase()
  return imageExts.indexOf(extension) > -1
}

export const mediaExts = ['.mp3', '.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.wav', '.flac', '.aac', '.ogg']
export function isMediaByPath(path) {
  const extension = '.' + path?.split('.').pop().toLowerCase()
  return mediaExts.indexOf(extension) > -1
}

export function isSameDirectory(filePath1 = '', filePath2 = '') {
  // 标准化路径分隔符（兼容 Windows 和 Unix）
  const normalizePath = (p) => p.replace(/\\/g, '/');
  const dir1 = normalizePath(filePath1).split('/').slice(0, -1).join('/');
  const dir2 = normalizePath(filePath2).split('/').slice(0, -1).join('/');
  return dir1 === dir2;
}

export function formatExifDate(dateStr) {
  if (!dateStr) return '';
  const year = dateStr.substring(0, 4);
  const month = dateStr.substring(4, 6);
  const day = dateStr.substring(6, 8);
  return `${year}:${month}:${day} 00:00:00`;
};

export async function fetchImageBlob(url) {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`图片下载失败: ${response.status}`);
  return await response.blob();
};

export const getCurrentDateStr = () => {
  const now = new Date();
  return `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, '0')}${now.getDate().toString().padStart(2, '0')}_${now.getHours().toString().padStart(2, '0')}${now.getMinutes().toString().padStart(2, '0')}`;
};

// 检查是否为有效JPEG
function isJPEG(blob) {
  console.log(222, blob.type)
  return blob.type === 'image/jpeg' ||
    blob.type === 'image/jpg' ||
    (blob.type === '' && blob.size > 2 &&
      new Uint8Array(blob.slice(0, 2))[0] === 0xFF &&
      new Uint8Array(blob.slice(0, 2))[1] === 0xD8);
}

const buildSafeExif = (exifObj = {}) => {
  // 确保所有必要的目录都存在
  const defaultExif = {
    '0th': {},
    'Exif': {},
    'GPS': {},
    'Interop': {},
    '1st': {},
    'thumbnail': null
  };

  // 合并原有数据（过滤无效值）
  const safeExif = { ...defaultExif };
  for (const section in exifObj) {
    if (defaultExif.hasOwnProperty(section)) {
      safeExif[section] = {};
      for (const tag in exifObj[section]) {
        const value = exifObj[section][tag];
        // 只保留字符串/数字类型的有效值
        if (typeof value === 'string' || typeof value === 'number') {
          safeExif[section][tag] = value;
        }
      }
    }
  }
  return safeExif;
};

const blobToDataURL = (blob) => {
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = () => {
      // 确保返回的是完整的 data URL
      const result = reader.result;
      if (typeof result === 'string' && result.startsWith('data:')) {
        resolve(result);
      } else {
        // 如果浏览器返回 ArrayBuffer，手动转换为 Base64
        const bytes = new Uint8Array(result);
        let binary = '';
        bytes.forEach((byte) => binary += String.fromCharCode(byte));
        resolve(`data:${blob.type};base64,${window.btoa(binary)}`);
      }
    };
    reader.readAsDataURL(blob);
  });
};

const safeDump = (exifObj) => {
  try {
    // 确保所有必要的字段都存在
    const safeExif = {
      '0th': {
        [piexif.ImageIFD.Make]: 'Unknown',
        [piexif.ImageIFD.Model]: 'Unknown',
        ...exifObj['0th']
      },
      'Exif': {
        [piexif.ExifIFD.DateTimeOriginal]: '2000:01:01 00:00:00',
        ...exifObj['Exif']
      },
      'GPS': {},
      'Interop': {},
      '1st': {},
      'thumbnail': null
    };
    return piexif.dump(safeExif);
  } catch (error) {
    console.error('EXIF dump 失败:', error);
    // 返回最小化的有效 EXIF
    return piexif.dump({
      '0th': {
        [piexif.ImageIFD.Make]: 'Unknown',
        [piexif.ImageIFD.Model]: 'Unknown'
      },
      'Exif': {
        [piexif.ExifIFD.DateTimeOriginal]: '2000:01:01 00:00:00'
      },
      'GPS': {},
      'Interop': {},
      '1st': {},
      'thumbnail': null
    });
  }
};


export async function modifyImageExif(imageUrl, { author, date }) {
  try {
    // 获取图片
    const response = await fetch(imageUrl);
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const blob = await response.blob();

    // 转换为标准的 Base64 Data URL
    const dataUrl = await blobToDataURL(blob);

    // 验证确实是 JPEG 图片
    if (!dataUrl.startsWith('data:image/jpeg')) {
      throw new Error('不是有效的JPEG图片');
    }

    // 加载 EXIF 数据
    let exifObj;
    try {
      exifObj = piexif.load(dataUrl);
    } catch (loadError) {
      console.warn('EXIF加载失败，创建新数据:', loadError);
      exifObj = { '0th': {}, 'Exif': {} };
    }

    // 设置目标字段
    exifObj['0th'][piexif.ImageIFD.Artist] = author || '';
    exifObj['Exif'][piexif.ExifIFD.DateTimeOriginal] = formatExifDate(date) || '2000:01:01 00:00:00';

    // 生成新的 EXIF 数据
    const newExif = safeDump(exifObj);

    // 插入 EXIF 并返回 Blob
    const modifiedDataUrl = piexif.insert(newExif, dataUrl);
    return await (await fetch(modifiedDataUrl)).blob();

  } catch (error) {
    console.error('EXIF修改失败:', error.message);
    // 返回原始图片作为降级方案
    try {
      return await (await fetch(imageUrl)).blob();
    } catch (fetchError) {
      throw new Error(`无法恢复原始图片: ${fetchError.message}`);
    }
  }
}
// 文件名处理函数
export const safeFileName = (name) => {
  // 保留中文及其他Unicode字符，仅替换危险字符
  return name.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_')
    .replace(/^\./, '_') // 避免隐藏文件
    .replace(/\s+/g, ' '); // 合并多余空格
}
// 图片路径标准化函数
export const normalizeImagePath = (imagePath) => {
  if (!imagePath) return ''

  let normalizedPath = imagePath
  // 检查是否为Windows路径（包含盘符）
  if (/^[A-Za-z]:\\/.test(normalizedPath)) {
      // Windows路径处理
      console.log('Windows路径')
      normalizedPath = normalizedPath.replace(import.meta.env.VITE_API_FOLDER_NAME || 'E:\\相片档案\\', '').replace(/\\/g, '/')
  } else if (normalizedPath.startsWith('/home/pic')) {
      // Linux路径处理
      normalizedPath = normalizedPath.replace('/home/pic/', '').replace(/\\/g, '/')
  } else if (normalizedPath.indexOf('\\') > -1) {
      // 绝对路径处理
      normalizedPath = normalizedPath.replace(/\\/g, '/')
  }
  return normalizedPath
}

// 解析图片路径 /home/pic/2025/0901/DJI_0008.JPG
export function parseImagePath(imagePath) {
    if (!imagePath) {
      return ''
    }
    const originPath = JSON.parse(JSON.stringify(imagePath))
    imagePath = normalizeImagePath(imagePath)
    console.log('imagePath', imagePath)
    let resultData = {
        defaultExpandedKeys: [import.meta.env.VITE_API_TREE_ROOT || 'pic'],
        currentNodeKey: ''
    }
    const parts = imagePath.split('/')
    const pathAar = parts.slice(0, -1)
    resultData.defaultExpandedKeys.push(...pathAar)
    resultData.currentNodeKey = originPath.replace(import.meta.env.VITE_API_FOLDER_NAME || 'E:\\相片档案\\', '')
    if (/^[A-Za-z]:\\/.test(import.meta.env.VITE_API_FOLDER_NAME)) {
      resultData.currentNodeKey = originPath.replace(import.meta.env.VITE_API_FOLDER_NAME || 'E:\\相片档案\\', '').replace(/\//g, '\\')
    }
    return resultData
}

export const getOrgIssueData = () => {
  return [
    { name: '领导人活动类', value: 'WLD' },
    { name: '时政要闻类', value: 'WSZ' },
    { name: '经济类', value: 'WJJ' },
    { name: '社会类', value: 'WSH' },
    { name: '教育类', value: 'WJY' },
    { name: '娱乐文化类', value: 'WYL' },
    { name: '军事类', value: 'WJS' },
    { name: '城市建设类', value: 'WCJ' },
    { name: '体育类', value: 'WTY' },
    { name: '文化遗产类', value: 'WWH' },
    { name: '医疗卫生类', value: 'WYW' },
    { name: '公检法类', value: 'WGJ' },
    { name: '农业农村类', value: 'WNY' },
    { name: '科技类', value: 'WKJ' },
    { name: '港澳台交流类', value: 'WGA' },
    { name: '报社活动类', value: 'WBS' }
  ]
}

// 转换单位名称
export const getOrgIssueName = (value, orgIssueData) => {
  const item = orgIssueData.find(item => item.id == value)
  return item?.unit_name || ''
}

// 判断是否为null
export const isNull = (value) => {
  return value === null || value === undefined
}

// 提取路径读取日期, 路径格式：E:\\相片档案\\2025\\9月\\0901\\军训\\20240603164433.jpg,返回日期：2025-09-01
export const extractDateFromPath = (path) => {
  if (!path) return ''
  let imagePath = normalizeImagePath(path)
  // 2025/9月/0901/军训/20240603164433.jpg 转换为 2025-09-01
  const parts = imagePath.split('/')
  if (parts.length < 3) return ''
  // 提取年份
  const year = parts[0]
  
  // 提取月份并格式化为两位数
  // 假设月份格式为'X月'，提取X部分
  const monthPart = parts[1]
  const month = monthPart.match(/\d+/)[0].padStart(2, '0')
  
  // 提取日期部分
  // 假设日期格式为'0901'，取后两位作为日期
  const datePart = parts[2]
  const date = datePart.slice(-2)
  const result = `${year}-${month}-${date}`
  return isDate(result) ? result : ''
}

// 判断是否为日期
export const isDate = (dateStr) => {
    // 检查参数是否为空或不是字符串
  if (!dateStr || typeof dateStr !== 'string') {
    return false;
  }
  
  // 创建Date对象尝试解析字符串
  const date = new Date(dateStr);
  
  // 检查是否为有效日期（isNaN(date.getTime())会判断是否为无效日期）
  // 同时需要检查原始字符串是否与日期对象的字符串表示匹配，避免像'2023-02-30'这样的无效日期被误判
  return !isNaN(date.getTime()) && 
         dateStr.trim().toLowerCase() !== 'invalid date' &&
         // 进一步验证：确保解析后的日期的年、月、日与输入字符串中的年、月、日一致
         (function() {
           // 尝试从常见格式中提取年月日
           const match = dateStr.match(/^(\d{4})[-\/](\d{1,2})[-\/](\d{1,2})/);
           if (!match) return true; // 如果不是常见的年-月-日格式，则依赖Date对象的判断
           
           const [, year, month, day] = match;
           return parseInt(year) === date.getFullYear() &&
                  parseInt(month) === date.getMonth() + 1 &&
                  parseInt(day) === date.getDate();
         })();
}